package com.example.project.utils;

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * 线程池工具类使用示例
 * 
 * 本类展示了ThreadPoolUtils工具类的各种使用场景：
 * 1. 基本异步执行
 * 2. 带异常处理的异步执行
 * 3. 有返回值的异步任务
 * 4. 批量任务执行
 * 5. 带超时的任务执行
 * 6. 线程池状态监控
 * 7. 优雅关闭机制
 * 
 * @author ruoyi
 */
public class ThreadPoolExample {

    public static void main(String[] args) {
        // 1. 创建线程池
        ThreadPoolTaskExecutor executor = ThreadPoolUtils.createDefaultThreadPool("example-pool");
        
        try {
            // 2. 基本异步执行示例
            basicAsyncExample(executor);
            
            // 3. 带异常处理的异步执行
            asyncWithExceptionHandling(executor);
            
            // 4. 有返回值的异步任务
            asyncWithReturnValue(executor);
            
            // 5. 批量任务执行
            batchTaskExecution(executor);
            
            // 6. 带超时的任务执行
            timeoutTaskExecution(executor);
            
            // 7. 获取线程池状态
            System.out.println("\n=== 线程池状态 ===");
            System.out.println(ThreadPoolUtils.getThreadPoolStatus(executor));
            System.out.println(ThreadPoolUtils.getTaskStatistics());
            
            // 等待所有任务完成
            Thread.sleep(2000);
            
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 8. 优雅关闭线程池
            ThreadPoolUtils.shutdownGracefully(executor);
        }
    }
    
    /**
     * 基本异步执行示例
     * 
     * 演示如何使用executeAsync方法执行无返回值的异步任务
     * 
     * @param executor 线程池执行器
     */
    private static void basicAsyncExample(ThreadPoolTaskExecutor executor) {
        System.out.println("=== 基本异步执行示例 ===");
        
        for (int i = 1; i <= 5; i++) {
            final int taskId = i;
            ThreadPoolUtils.executeAsync(executor, () -> {
                System.out.println("执行任务 " + taskId + " - 线程: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(100); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
    }
    
    /**
     * 带异常处理的异步执行
     * 
     * 演示如何使用executeAsync方法执行带异常处理的异步任务
     * 
     * @param executor 线程池执行器
     */
    private static void asyncWithExceptionHandling(ThreadPoolTaskExecutor executor) {
        System.out.println("\n=== 带异常处理的异步执行 ===");
        
        ThreadPoolUtils.executeAsync(executor, () -> {
            System.out.println("执行可能失败的任务...");
            if (Math.random() > 0.5) {
                throw new RuntimeException("模拟任务失败");
            }
            System.out.println("任务执行成功");
        }, e -> {
            System.err.println("捕获到异常: " + e.getMessage());
            // 这里可以记录日志、发送告警等
        });
    }
    
    /**
     * 有返回值的异步任务
     * 
     * 演示如何使用submitAsync方法执行有返回值的异步任务
     * 
     * @param executor 线程池执行器
     */
    private static void asyncWithReturnValue(ThreadPoolTaskExecutor executor) {
        System.out.println("\n=== 有返回值的异步任务 ===");
        
        Callable<String> task = () -> {
            Thread.sleep(200);
            return "异步任务结果: " + System.currentTimeMillis();
        };
        
        CompletableFuture<String> future = ThreadPoolUtils.submitAsync(executor, task);
        
        future.thenAccept(result -> {
            System.out.println("接收到结果: " + result);
        }).exceptionally(e -> {
            System.err.println("任务执行异常: " + e.getMessage());
            return null;
        });
    }
    
    /**
     * 批量任务执行
     * 
     * 演示如何使用executeBatch方法批量执行任务
     * 
     * @param executor 线程池执行器
     */
    private static void batchTaskExecution(ThreadPoolTaskExecutor executor) {
        System.out.println("\n=== 批量任务执行 ===");
        
        List<Runnable> tasks = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            final int taskId = i;
            tasks.add(() -> {
                System.out.println("批量任务 " + taskId + " 开始执行");
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("批量任务 " + taskId + " 执行完成");
            });
        }
        
        CompletableFuture<Void> batchFuture = ThreadPoolUtils.executeBatch(executor, tasks);
        
        batchFuture.thenRun(() -> {
            System.out.println("所有批量任务执行完成");
        });
    }
    
    /**
     * 带超时的任务执行
     */
    private static void timeoutTaskExecution(ThreadPoolTaskExecutor executor) {
        System.out.println("\n=== 带超时的任务执行 ===");
        
        Callable<String> longRunningTask = () -> {
            Thread.sleep(3000); // 3秒的任务
            return "长时间运行的任务结果";
        };
        
        try {
            String result = ThreadPoolUtils.executeWithTimeout(executor, longRunningTask, 1, TimeUnit.SECONDS);
            System.out.println("任务结果: " + result);
        } catch (TimeoutException e) {
            System.err.println("任务超时: " + e.getMessage());
        } catch (Exception e) {
            System.err.println("任务执行异常: " + e.getMessage());
        }
    }
}